Pascal Super Library/Pascal Super Library (CW International)(1997).bin/LIBRARY/RTPC10/MANUAL.TXT

Text File | 1993-11-22 | 40KB | 1,169 lines

                  Rafe's
                    TP
                Collection

                   Release 1.0

                 By Rafe Aldridge

                   Street Farm,
                  Dereham Road,
                   Garvestone,
                Norfolk.
                NR9 4QT
                ENGLAND

           E-Mail
           until July 1994: [e-mail]
  then from September 1994 to July 1995: [e-mail]

(if this doesn't work check the username with [e-mail])

Welcome, Disclaimer etc.

Thanks for taking the time to look at my collection of stuff for
Turbo Pascal Versions 6 and 7. Hopefully, you will find it
useful and will learn something from it. Please feel free to
write to me with any ideas or comments at the address shown at
the front of this document.

This collection is distributed as shareware as it's taken me a
long time to compile this collection and a large proportion of
my student loan has gone to Borland in order for it to happen.
So if  you find any part of Rafe's TP Collection useful then
please become a registered user by sending 10 Pounds Sterling
(plus shipping which is free in the UK, £1 for Europe and £2 for
the rest of the world) to the address given at the front of this
document. In return you will receive the LATEST  FULL source
code to ALL the units as well anything new. When you do register
please try and use the registration form on the next page. This
is also duplicated in REGISTER.FRM so you can either edit it
in your favourite word processor or print out a copy with COPY
REGISTER.FRM PRN. Apologies for the copyright message which will
appear if you use the units but I want to encourage you to
register (registered units don't have it).

Please feel free to make copies of this collection, pass it onto
friends, upload it to BBSs, FTP it across the globe, whatever,
so long as it stays complete. NOTE to vendors:  Please drop me a
note when adding the collection to your library. I would like to
hear from you.

Finally, just to cover myself, I must say: THIS SOFTWARE AND
MANUAL ARE  DISTRIBUTED "AS IS" AND WITHOUT ANY WARRANTIES AS TO
PERFORMANCE OF MERCHANTABILITY OR ANY OTHER WARRANTIES WHETHER
EXPRESSED OR IMPLIED. BECAUSE OF THE VARIOUS HARDWARE AND
SOFTWARE ENVIRONMENTS  THAT THIS SOFTWARE CAN BE PUT, NO
WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE IS OFFERED. GOOD
DATA PROCESSING PROCEDURE DICTATES THAT ANY PROGRAM BE
THOROUGHLY TESTED WITH NON-CRITICAL DATA BEFORE RELYING ON IT.
THE USER MUST ASSUME THE ENTIRE RISK OF USING THE UNITS OR
SAMPLE CODE. ANY LIABILITY OF THE SELLER WILL BE LIMITED
EXCLUSIVELY TO PRODUCT REPLACEMENT OR REFUND OF THE PURCHASE
PRICE.

Thanks again.

Rafe Aldridge.

Everything in Rafe's TP Collection is Copyright 1993 by Rafe Aldridge.

Registration Form

Send to:
Rafe Aldridge,
Street Farm,
Dereham Road,
Garvestone,
Norfolk.
NR9 4QT
England

Please make cheques payable to Rafe Aldridge and write your card
number on the reverse.

I would like to register Rafe's TP Collection Version 1.0. My
details are as below and I enclose a cheque for £10 (pounds
sterling) plus shipping (free if in UK, £1 for Europe and £2 for
the rest of the world).

Name
Company
Address
Town
City
Postcode
Country
Telephone  (optional)
E-Mail Address
Disk Size Required       o 3.5" LD     o 3.5" HD     o 5.25" HD
I got  Rafe's TP Collection from:
Which is a:      o BBS     o FTP Site     o Mail Server     o Shareware Vendor

Archive Contents

The following files will be found in the archive:

Filename        Description
BASEN.TP?       A unit for converting between various number bases
BASEN_D.PAS     Example program for the above
BLANK.PAS       Example program that acts as a screen blanker.
CLICK.PAS       Example program demonstrating the writing of simple TSRs
DESIGN.EXE      Program to aid the design of VGA characters
DISKSUM.PAS     Example program showing a recursive disk search
DJDUMP.PAS      Example procedure for dumping graphics to the HP DeskJet
GCLOCKS.TP?     A unit for displaying analogue / digital clocks in
        graphics modes (requires GRAPH)
GRAFIX.TP?      A unit for to supplement the graph unit (including
        faster plot routine)
JOKE.PAS        Example program demonstrating avoiding re-entrancy in TSRs
MATHS.TP?       A unit of maths functions not included as standard
        with TP/BP
MATRICES.TP?    A unit for manipulating small (5x5) matrices
MDA.TP?         A unit for controlling a MDA (monochrome display adaptor)
MOUSE.TP?       A unit for using a mouse in your programs
MOUSE_D.PAS     Example program for the above
NO_MD_RD.ASM    Assembler program demonstrating a simple TSR
SCREEN.TP?      A unit with some usefull text based routines
VGA.TP?         A unit to aid programming in 320x200x256 VGA graphics mode
VGA_D.PAS       Example program for the above
MANUAL.TXT      The manual in plain text format
MANUAL.PS       The manual typeset in PostScript format (22 Pages).
READ.ME         Last minute additions and the ususal stuff
RAFETP.DIZ      Description for vendors
INSTALL6.BAT    A batch file to set up Rafe-TP for TP6
INSTALL7.BAT    A batch file to set up Rafe-TP for TP/BP7
REGISTER.FRM    Registration Form

The Programs

Blank.pas
This demonstrates the writing of simple TSRs in Turbo Pascal.
It hooks both the keyboard and timer intterupts and acts as
a screen saver.

Click.pas
This demonstrates the writing of very simple TSRs in Turbo
Pascal. Basically it hooks the keyboard interrupt and makes a
click every time a key is pressed. This program also
demonstrates how to keep data in the code segment.

Design.exe
This is a simple program to help design characters for use with
the def_char procedure from the screen unit.

Disksum.pas
This is an example of recursion in Turbo Pascal by means of a
recursive disk search

DJDump.pas
Although not a complete program this example procedure shows how
to dump graphics to the HP DeskJet. It also includes a small
piece of assembler to read pixels of a graphics screen without
the need of the Graph unit and BGI. NOTE: it was written for use
with the 640x480x16 VGA graphics mode.

Joke.pas
Another example of simple TSRs that also demonstrates how to
avoid re-entrancy.

No_md_rd.asm
Assembler program demonstrating a simple TSR. Seeing as
TASM comes with Turbo Pascal Professional and Borland Pascal I
thought I'd include this for the adventurous.

The Units

All the units were compiled with the switches {$D-,L-,R-} except
for the Maths unit which was compiled with {$D-,E+,L-,N+,R-}.
Hopefully these will be okay for most purposes otherwise
register and you can compile them with whatever switches you
desire.

Below is an alphabetical list of all the procedures found in the
various units, supplied as part of the Rafe-TP collection, in
the style of the Turbo Pascal manuals.

The following is a sample table.

Sample procedure - Unit it occupies
Function        What it does
Declaration     How it is declared in the unit
Result Type     If a function this gives the type of result
Remarks         General information
Restrictions    Restrictions or points to watch out for
Example         An example if applicable

Add_Matrix procedure - Matrices
Function        Adds two matrices.
Declaration     Add_Matrix ( M1,M2 : Matrix; var M : Matrix );
Remarks         Returns in matrix M the sum of M1 and M2.

AFace procedure - GClocks
Function        Displays an analogue clockface.
Declaration     AFace (X,Y,L : Integer);
Remarks         Displays dots for an analogue clockface. The center of
        the clockface is X,Y and the radius of the clockface is L.
Restrictions    Must be in graphics mode and be using the Graph unit
Example         See AHands Procedure.

AHands procedure - GClocks
Function        Displays a analogue clockface.
Declaration     AHands (X,Y,L : Integer; H,M : Word);
Remarks         Displays the hands of an analogue clock. The time is
        given by H:M and the centre of the clock
        face is X,Y and the length of the minute hand is given by L.
Restrictions    Must be in graphics mode and be using the Graph unit
Example
    Uses GClock;
        Var H,M,S,SS,OH,OM : word;
    Begin
        { set up graphics mode here }
        Repeat
            AFace(50,50,28);
            GetTime(H,M,S,SS);
            If M<>OM then
            Begin
                SetColor(Black);
                AHands(50,50,25,OH,OM);
                SetColor(White);
                AHands(50,50,25,H,M);
                OM:=M;
                OH:=H;
            End;
        Until False;
    End.

Bin function - Basen
Function        Converts a decimal value into a binary string.
Declaration     Bin ( Length : Byte; Dec_Val : Word; LZero : boolean );
Result Type     String
Remarks         Converts Dec_Val into a string of Length representing
        the binary equivalent. If LZero is true then leading zeros
        are suppressed. Length is between 1 and 16.
Example
    Uses Basen;
    Begin
        Writeln (Bin(4,5,True));{ 101 }
        Writeln (Bin(4,5,False)); { 0101 }
    End.

BinByte function - Basen
Function        Converts a binary number  into a byte.
Declaration     BinByte ( S : String );
Result Type     Byte
Remarks         Converts a binary number stored in string S into the
        decimal equivelent. Note that the length of S must be 8
        characters - otherwise the value returned will be 0.
Example
    Uses Basen;
    Begin
        Writeln (BinByte ('10101010'));
    End.

Blink_Disable - Mda
Function        Disables blinking on the MDA Screen
Declaration     Blink_Disable;

Blink_Enable - Mda
Function        Enables blinking on the MDA Screen
Declaration     Blink_Enable;

Box procedure - Screen
Function        Draws a shadowed box on the text screen.
Declaration     Box (X1,Y1,X2,Y2 : Byte; C : Char;  T : String);
Remarks         Draws a box in double lines using character C for the
        shadow. The top of the box can contain a title, T. X1,Y1
        is the top left hand corner of the box while X2,Y2 is the
        bottom right corner.

Clear_Box procedure - Screen
Function        Clears part of thescreen.
Declaration     Clear_Box ( C : Byte; var H : Hidden_Area );
Remarks         Clears a 20x10 box in the centre of the screen coloured
        C. The previous contents are stored in H ready to be replaced
        by Restore_Box.
Example         See Restore_Box.

CloseVGA procedure - VGA
Function        Close the VGA graphics mode.
Declaration     CloseVGA;
Remarks         This closes the VGA graphics mode and returns to
        80x25x16 text mode.

Cosh function - Maths
Function        Returns the Hyp Cosine of the argument.
Declaration     Cosh (X : Real);
Result Type     Real
Remarks         X is a real type expression. The result is Hyp Cosine of X.
Example
        Uses Maths;
        Begin
            Writeln (Cosh(2));  { 3.7621 }
            Writeln (Cosh(-4)); { 27.308 }
        End.

Create_Matrix procedure - Matrices
Function        Creates a matrix
Declaration     Create_Matrix ( R,C : Byte; var M : Matrix );
Remarks         Creates an empty matrix, M, with R rows and C columns.

CursorOn procedure - Screen
Function        Turns the text cursor on and sets the start and stop
        scan lines.
Declaration     CursorOn ( H,L : Byte );
Remarks         Turns the text cursor on. Cursor starts at line L and
        finishes at line H. L and H are between 0 and 7 for 25 line
        mode and between 0 and 15 for 43 or 50 line mode. If L and H
        are both set greater than 15 then the default cursor is set.
Example
        Uses Text;
        Begin
            CursorOff;
            Writeln ('Return to Show Cursor');
            Readln;
            CursorOn (0,7);
            Writeln ('Return to Reset Cursor');
            Readln;
            CursorOn (16,16);
        End.

CursorOff procedure - Screen
Function        Turns the text Cursor off.
Declaration     CursorOff;
Remarks         Use CursorOn to retrieve cursor.
Example         See CursorOn.

D2R function - Maths
Function        Converts degrees to degrees radians.
Declaration     D2R ( X : Real );
Result Type     Real
Remarks         X is a real type expression representing an angle in
        degrees. The result represents the angle in degrees radians.
Example
        Uses Maths;
        Begin
            Writeln (D2R(90));{ 1.57 }
        End.

Def_Char procedure - Screen
Function        Redefines a VGA text character.
Declaration     Def_Char (CT_Ofs, CT_Seg, N, C : Word);
Remarks         A VGA character is 8x16 pixels and can therefore be
        described in a 16 byte array where each byte in binary
        represents which pixels will be lit on that line. Def_Char
        can be used to redefine a VGA character from such an array.
        CT_Seg:CT_Ofs points to the array (which can contain more
        than one set of 16 Bytes). N represents the number of
        characters to redefine and C is the starting character.
        The program DESIGN.EXE, supplied with this collection
        can be used to define these characters.
Example
        Uses Screen;
            Const New_Char : array [1..16] of byte =
            (1,2,4,8,16,32,64,128,255,128,64,32,16,8,4,2,1);
        Begin
            Def_Char (Ofs (New_Char), Seg (New_Char, 1, 128);
            Write ('Character 128 has been redefined ');
            Write (#128);
            Writeln;
            Writeln ('Use the DOS command MODE CO80 to reset
        the character set');
        End.

Display_Matrix procedure - Matrices
Function        Used to display a matrix.
Declaration     Display_Matrix ( X, Y : Byte; M : Matrix );
Remarks         Outputs the matrix M to the screen at the position given
        by X,Y.

DClock procedure - GClocks
Function        Displays a digital clock on the screen.
Declaration     DClock (X,Y : Integer; H,M,S : Word);
Remarks         Displays the time in the format HH:MM:SS in the current
        colour and character size. The current justification is also
        used. X,Y is the position of the clock.
Restrictions    Must be in graphics mode and be using the Graph unit.
Example
        Uses GClocks;
            Var H,M,S,SS,OH,OM,OS : word;
        Begin
            { set up graphics mode here }
            Repeat
                GetTime(H,M,S,SS);
                If S<>OS then
                Begin
                    SetColor(Black);
                    DClock(50,50,OH,OM,OS);
                    SetColor(White);
                    DClock(50,50,H,M,S);
                    OS:=S;
                    OM:=M;
                    OH:=H;
                End; {if}
            Until False;
        End;

DCos function - Maths
Function        Returns the cosine of the argument.
Declaration     DCos ( X : Real );
Result Type     Real
Remarks         X is a real type expression. The result is the cosine
        of X. Where X is assumed to be an angle in degrees.
Example
        Uses Maths;
        Begin
            Writeln (DCos(90)); { 0 }
        End;

DSin function - Maths
Function        Returns the sine of the argument.
Declaration     DSin ( X : Real );
Result Type     Real
Remarks         X is a real type expression. The result is the sine of
        X. Where X is assumed to be an angle in degrees.
Example
        Uses Maths;
        Begin
            Writeln (DSin(90)); { 1 }
        End.

DTan function - Maths
Function        Returns the tangent of the argument.
Declaration     DTan ( X : Real );
Result Type     Real
Remarks         X is a real type expression. The result is the tangent
        of X. Where X is assumed to be an angle in degrees.
Example
        Uses Maths;
        Begin
            Writeln (DTan(180)); { 0 }
        End.

Empty_Elements constant - Matrices
Function        An empty matrix (see Matrix type)
Declaration     const empty_elements : elements = (
                        (0,0,0,0,0),
                        (0,0,0,0,0),
                        (0,0,0,0,0),
                        (0,0,0,0,0),
                        (0,0,0,0,0));

Empty_Matrix procedure - Matrices
Function        Empties a matrix.
Declaration     Empty_Matrix (var M : Matrix);
Remarks         Returns M empty.

ESetRes procedure - Grafix
Function        Puts a value into the VGA ESetRes register.
Declaration     ESetRes (P : Byte);
Remarks         The byte P will be placed into the register.

Factorial function - Maths
Function        Returns the factorial of the argument.
Declaration     Factorial ( X : Integer );
Result Type     Real
Remarks         X is an integer type expression. The result is the
        factorial of X otherwise known as X!.
Example
        Uses Maths;
        Begin
            Writeln (Factorial(5)); { 125 }
        End.



FastPlot procedure - Grafix
Function        Plots a pixel onto an EGA/VGA screen.
Declaration     FastPlot (X,Y : Word; C : Byte);
Remarks         Plots a pixel at X,Y in colour C. This routine contains
        no error checking to see whether the screen is in graphics
        mode. It is at least three times faster than the Graph
        PutPixel procedure.
Restrictions    Must be in graphics mode.

FlyBack function - VGA
Function        Waits for a screen flyback.
Declaration     FlyBack;
Remarks         This waits for a screen flyback to occur.

GetButton  function - Mouse
Function        Returns status of the mouse buttons.
Declaration     GetButton;
Result Type     Byte
Remarks         The returned byte contains the status of the mouse
        buttons. If a button is down then it's corresponding bit is
        set. Bit 0 represents the left button, bit 2 the middle
        button and bit 1 the right button.
Restrictions    If the code between different calls to GetButton is
        small then the results may conflict. If this
        does occur then use a DELAY statement from the CRT unit to
        pad out your code. 250mS should be ample.
Example
        Uses Mouse;
        Begin
            if not MReset then Halt(0);
            Writeln ('Press left mouse button');
            repeat until GetButton=1;
            Writeln ('Press right mouse button');
            repeat until GetButton=2;
        End.

GetButtonPress procedure - Mouse
Function        Retrieve information about a button press.
Declaration     GetButtonPress ( Button : Byte; var BPN,X,Y : Word;);
Remarks         Button is equal to 0 for the left button, 2 for the
        middle button and 1 for the right button. BPN
        is the number of times that Button has been pressed since the
        last time that this procedure was called for that Button.
        X and Y contain the coordinates of the last Button press.
Example
        Uses Mouse;
            Var BPN,X,Y : Word;
        Begin
            if not MReset then Halt(0);
            Writeln ('Press left button a few times and then
        press the right button.');
            GetButtonPress (0,BPN,X,Y);
            repeat until GetButton=2;
            GetButtonPress (0,BPN,X,Y);
            Writeln ('You pressed the left button ',BPN,'
        times.');
        End.

GetButtonRelease procedure - Mouse
Function        Retrieve information about a button release.
Declaration     GetButtonRelease ( Button : Byte; var BRN,X,Y : Word; );
Remarks         Button is equal to 0 for the left button, 2 for the
        middle button and 1 for the right button. BRN is the number
        of times that Button has been released since the last time
        that this procedure was called for that Button. X and Y
        contain the co-ordinates of the last Button release.
Example See GetButtonPress

GetMotion procedure - Mouse
Function        Reads and returns the value of the mouse motion counters.
Declaration     GetMotion ( var X,Y : Integer );
Remarks         The values X and Y are the net mouse displacement since
        the last call to this procedure. They are measured in mickeys,
        where 1 mickey equals 1/200". A positive number indicates
        movement to the right or downwards.
Example
        Uses Mouse;
            Var X,Y : Integer;
        Begin
            if not MReset then Halt(0);
            repeat
                GetMotion (X,Y);
                if X<0 then Writeln ('Right');
                if X>0 then Writeln ('Left');
                if Y<0 then Writeln ('Up');
                if Y>0 then Writeln ('Down');
            until GetButton>0;
        End.

GetPos procedure - Mouse
Function        Get current posistion of mouse.
Declaration     GetPos ( var X,Y : Word );
Remarks         GetPos returns in X and Y the current coordinate of the
        mouse pointer, it is always measured in pixels.
Example
        Uses Crt,Mouse;
            Var X,Y : Word;
        Begin
            if not MReset then Halt(0);
            repeat
                ClrScr;
                GetPos (X,Y);
                Writeln ('X: ',X,'Y:',Y,'');
            until GetButton>0;
        End.

Hex function - Basen
Function        Converts a decimal value into a hexidecimal string.
Declaration     Hex ( Length : Byte; Dec_Val : Word; LZero : Boolean );
Result Type     String
Remarks         Converts Dec_Val into a string of Length representing
        the Hexidecimal equivalent. If LZero is True then leading
        zeros are suppressed.
Restrictions    Length must be between 1 and 4.
Example
        Uses Basen;
        Begin
            Writeln (Hex(4,1234,True));{ 4D2 }
            Writeln (Hex(4,1234,False)); { 04D2 }
        End.

HexArray constant - Basen
Function        Constant array containing the Hexidecimal numbers.
Declaration     HexArray : Array [0..15] of Char = (
'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');

Hidden Area type - Screen
Function        Used with Restore_Box and Clear_Box.
Declaration     Type Hidden_Area = array [1..280] of Word;

HLine procedure - VGA
Function        Draws a horizontal line in mode 13h.
Declaration     HLine ( L,X,Y : Word; Col : Byte );
Remarks         Draws a horizontal line of length L starting at X,Y and
        in colour  Col in mode 13h (320x200x256 VGA graphics mode).

Input_Matrix procedure - Matrices
Function        Used to input a matrix.
Declaration     Input_Matrix ( X,Y : Byte; M : Matrix );
Remarks         Allows the user to enter the elements of a matrix. The
        resultant matrix is stored in M and is input with the top
        left corner given by X,Y.
Example
        Uses CRT, Matrices;
            Var M, NM : Matrix;
        Begin
            ClrScr;
            Create_Matrix ( 3,3,M ); { create a 3x3 matrix }
            Input_Matrix (1,1,M); { get some elements }
            Add_Matrix ( M,M,NM ); { add matrix to itself }
            Display_Matrix (10,10,M); { display it }
        End.

IsIt function - Mouse
Function        Determines whether or not the pointer is in a given area.
Declaration     IsIt ( X1,Y1,X2,Y2 : Word );
Result Type     Boolean
Remarks         X1 and Y1 are the coordinates of the top left hand
        corner of a rectangular region of the screen. X2 and Y2 are
        the coords of the bottom right hand corner. IsIt returns true
        if the mouse pointer lies in this region.
Example
        Uses Mouse;
        Begin
            if not MReset then Halt(0);
            SetPointer (True);
            repeat
                if IsIt(0,0,640,8) then
                    Writeln ('Mouse Pointer on line 1');
                end; { if }
            until GetButton>0;
        End.

IsVGA function - VGA
Function        Checks to see if the display adaptor is VGA.
Declaration     IsVGA;
Result Type     Boolean
Remarks         This returns true if the display adaptor is a VGA
        compatible one.

KeyPress function - Screen
Function        Checks to see if a keypress has occured.
Declaration     KeyPress;
Result Type     Boolean
Remarks         This  returns true if a key has been pressed. Unlike
        the CRT KeyPressed extended keys are also detected.

Matrix type - Matrices
Function        Defines a type for use in Matrices
Declaration     Type    Elements = array [1..5,1..5] of integer;
        Type    Matrix = record
                    Cols : Byte;
                    Rows : Byte;
                    Element   : Elements;
                 End;

MDA_Clear - Mda
Function        Clears the MDA Screen
Declaration     MDA_Clear;
Remarks         A sort of ClrScr for the MDA.

MDA constants - Mda
Function        Defines constants for the various screen attributes. B
        stands for Bold.
Declaration     Const   Invisible = $0000;
            Underline = $0100;
            Normal = $0700;
            BUnderline = $0900;
            Bold = $0F00;
            Reverse = $7000;
            Blink = $8700;
            BBlink = $8F00;
            BReverse = $F000;

MDA_Style variable - Mda
Function        Dictates the style used with MDA_Write and MDA_Wrint.
        It can be assigned any of the values given in MDA constants.
Declaration     var MDA_Style : word;

MDA_Wrint procedure - Mda
Function        Writes an integer on an MDA Screen
Declaration     MDA_Wrint ( X,Y,L : Byte; I : Integer);
Remarks         Writes the integer, I, (including Bytes and Words) on
        the MDA screen at the position X,Y with length L. The style
        is given by the MDA_Style variable.
Example         See MDA_Write.

MDA_Write procedure - Mda
Function        Writes a string on an MDA Screen
Declaration     MDA_Write ( X,Y : Byte; S : String);
Remarks         Writes the string, S, on the MDA screen at the position
        X,Y. The style is given by the MDA_Style variable.
Example
        Uses Mda;
        Begin
            MDA_Clear;
            MDA_Style:=Reverse; { use reverse video }
            MDA_Wrint (10,10,5,1000); { write 1000 on the MDA }
            MDA_Style=BUnderline; { use bold and underline }
            MDA_Write (20,20,'Bold and Underlined!');
            ReadLn;
        End.

MReset function - Mouse
Function        Resets mouse.
Declaration     MReset;
Result Type     Boolean
Remarks         This  should always be called at the start of a program
        that uses Mouse. It will return True if a valid mouse driver
        is found. This  also does the following:
            Y The pointer is centralised and hidden.
            Y The Display page is set to 0 and the default shapes
              and styles for the pointer are employed.
            Y Limits are set to be the entire screen.
Example
        Uses Mouse;
        Begin
            if not MReset then
                Writeln ('No Mouse Driver!');
            else
                Writeln ('Mouse Driver Found!);
        End.

Multiply_Matrix procedure - Matrices
Function        Multiplies two matrices.
Declaration     Multiply_Matrix ( M1, M2 : Matrix; var M : Matrix );
Remarks         Returns in matrix M the result of M1*M2.

Oct function - Basen
Function        Converts a decimal value into an octal string.
Declaration     Oct ( Length : Byte; Dec_Val : Word; LZero : Boolean );
Result Type     String
Remarks         Converts Dec_Val into a string of Length representing
        the Octal Equivalent. If LZero is True then leading zeros are
        suppressed.
Restrictions    Length must be between 1 and 6.
Example
        Uses Basen;
        Begin
            Writeln (Oct(4,20,True)); { 24 }
            Writeln (Oct(4,20,False)); { 0024 }
        End.

Offset procedure - Grafix
Function        Puts a value into the VGA Offset register.
Declaration     Offset (P : Byte);
Remarks         The byte P will be placed into the register.

OpenVGA procedure - VGA
Function        Switches to mode 13h
Declaration     OpenVGA;
Remarks         Makes mode 13h the current mode (320x200x256 VGA
        graphics mode). Check that the card is a VGA with IsVGA
        before using this procedure.

PelPan procedure - Grafix
Function        Puts a value into the VGA PelPan register.
Declaration     PelPan (P : Byte);
Remarks         The byte P will be placed into the register.

Power function - Maths
Function        Returns arg1 to the power of arg2.
Declaration     Power (Arg1 : Integer; Arg2 : Real);
Result Type     Real
Remarks         Returns Arg1 to the power of Arg2 i.e. Arg1Arg2.
Example
        Uses Maths;
        Begin
            Writeln ('5^3=',Power(5,3)); { 125 }
        End;

PreRow procedure - Grafix
Function        Puts a value into the VGA PreRow register.
Declaration     PreRow (P : Byte);
Remarks         The byte P will be placed into the register.

PutPixel procedure - VGA
Function        Colours a pixel in mode 13h.
Declaration     PutPixel ( X,Y : Word; Col : Byte );
Remarks         Sets the pixel at X,Y to colour Col in mode 13h
        (320x200x256 VGA graphics mode).

R2D function - Maths
Function        Converts degrees radians to degrees.
Declaration     R2D ( X : Real );
Result Type     Real
Remarks         X is a real type expression representing an angle in
        degrees radians. The result represents the angle in degrees.
Example
        Uses Maths;
        Begin
            Writeln (R2D(1.57));{ 90 }
        End.

Replicate procedure - Screen
Function        Outputs multiple copies of a character.
Declaration     Replicate (N : Word; C : Char);
Remarks         Writes N copies of C starting at the current cursor
        location and in the current screen colours.

Restore_Box procedure - Screen
Function        Replaces a hidden area.
Declaration     Restore_Box ( H : Hidden_Area );
Remarks         H represents a 20x10 box removed from the screen. This
        procedure simply replaces it.
Example
        Uses Screen;
            Var H : Hidden_Area;
        Begin
            Clear_Box (10,H);
            Repeat Until Keypress;
            Restore_Box (H);
        End.

RTan function - Maths
Function        Returns the tangent of the argument.
Declaration     RTan ( X : Real );
Result Type     Real
Remarks         X is a real type expression. The result is the tangent
        of X. Where X is assumed to be an angle in degrees radians.
Example
        Uses Maths;
        Begin
            Writeln (RTan(PI)); { 0 }
        End.

ScreenOff procedure - Grafix
Function        Turns an EGA/VGA screen off.
Declaration     ScreenOff ;
Remarks         Turns the screen off. Does not have to be in graphics mode.

ScreenOn procedure - Grafix
Function        Fucntion Turns an EGA/VGA screen on.
Declaration     ScreenOn;
Remarks         Turns the screen on. Does not have to be in graphics mode.

SearchString function - Screen
Function        Checks to see if a substring exists in a string.
Declaration     SearchString ( S,SS : String );
Result Type     Boolean
Remarks         Returns True if SS exists in S. Lower and Upper case
        are different. Use UpString to convert both strings to
        uppercase if no distinction between case is required.
        e.g. SearchString (UpString(s),UpString (ss));

SetActivePage - Grafix
Function        Alters the active page.
Declaration     SetActivePage ( P : Byte );
Remarks         Sets the active page to be P. No checking is done to
        see if this is a valid page or not.

SetGPointer procedure - Mouse
Function        Defines the shape, colour and hotspot of the pointer
        in graphics modes.
Declaration     SetGPointer ( X,Y,OS,SE : Word );
Remarks         X and Y are the coordinates of the hotspot relative to
        the top left corner of the pointer (0,0).
        SE:OS points to a pointer image buffer which is 64 bytes long.
        The first 32 bytes contain an ANDed bitmask whilst the second
        32 bytes contain a XORed bitmask. The pointer is 16x16
        pixels. The layout of the buffer is a 64 byte array. When
        arranged in a 32 row by 2 coloumn layout the first coloumn
        represents the right half of the pointer and the second
        column represents the left half (I know it's backwards but I
        never wrote it!). The AND and XOR bits do the following.

        AND bit      XOR bit   resultant pixel colour
        0            0         background
        0            1         XOR background
        1            0         foreground (see thro')
        1            1         XOR foreground
Example
        { A 16x16 hollow box would be defined as a
        mixture of the following:-
        $80 in binary  $01 in binary
        10000000       00000001
        11111111       11111111
        $FF in binary  $FF in binary
        The hotspot is in the top left corner.}
        Const
            Box : Array [1..63] of Byte = (
                        $FF,$FF,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $FF,$FF,
                        $FF,$FF,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $01,$80,
                        $FF,$FF);
        Begin
            { set up graphics display here }
            If not MReset then Halt (0);
            SetPointer (True);
            SetGPointer (1,1,Ofs(Box),Seg(Box));
            repeat until GetButton>0;
        End.

SetLimits procedure - Mouse
Function        Limits the mouse pointer display area.
Declaration     SetLimits ( X1,Y1,X2,Y2 : Word );
Remarks         Sets the limits for the mouse pointer by assigning an
        area where the pointer is restricted to. The mouse pointer
        will be moved (if necessary) to fit in the area. The area is
        a rectangle with X1,Y1 being the coordinate of the top left
        corner and X2,Y2 being the coordinate of the bottom right
        corner.
Example
        Uses Mouse;
        Begin
            if not MReset then Halt (0);
            SetPointer (True);
            Writeln ('Mouse restricted to top half of the
        screen.');
            SetLimits (0,100,632,100);
            repeat until GetButton>0;
        End.

SetMode procedure - Grafix
Function        Puts the screen into a different mode.
Declaration     SetMode ( P : Byte  );
Remarks         Sets the screen mode to that of P. Note that this
        procedure does not check to see if P is a valid mode.

SetNoLimits procedure - Mouse
Function        Defines an exclusion area for the pointer.
Declaration     SetNoLimits ( X1,Y1,X2,Y2 : Word );
Remarks         X1,Y1 are the coordinates of the top left corner of a
        rectangle. X2,Y2 are the coordinates of the bottom right hand
        corner. The mouse pointer will not be displayed whilst in
        this area. The exclusion area is replaced with another call
        to SetNoLimits or cancelled with a call to SetPointer (True)
        or MReset.
Example
        Uses Mouse;
        Begin
            if not MReset then Halt(0);
            SetPointer (True);
            Writeln ('Mouse pointer will not be shown in center of
        screen');
            SetNoLimits (220,50,420,150);
            repeat until GetButton>0;
            SetPointer (True);
        End.

SetPointer procedure - Mouse
Function        Hides and shows mouse pointer.
Declaration     SetPointer ( Point : Boolean );
Remarks         If point is True then the mouse pointer is displayed
        otherwise if point is False then the pointer is hidden.
Example
        Uses Crt,Mouse;
        Begin
            if not MReset then Halt(0);
            Writeln ('Press a button to show pointer');
            repeat until GetButton>0;
            Delay (250);{ see GetButton for this }
            SetPointer (True);
            Writeln ('Press a button to exit');
            repeat until GetButton>0;
        End.

SetPointerPage procedure - Mouse
Function        Selects the display page for the mouse pointer.
Declaration     SetPointerPage ( Page : Byte );
Remarks         Page is the page number where the pointer will be
        displayed. Valid page numbers depend on the current display
        mode.

SetPos procedure - Mouse
Function        Set posistion of mouse pointer.
Declaration     SetPos ( X,Y : Word );
Remarks         Moves the mouse pointer to coordinate X,Y. The
        posistion is adjusted ( if necessary ) to lie within the
        boundry defined by SetLimits.
Example
        Uses Mouse;
            Var X,Y : Word;
        Begin
            if not MReset then Halt(0);
            SetPointer (True);
            Write ('Enter X coord: ');
            Readln (X);
            Writeln;
            Write ('Enter Y coord: ');
            Readln (Y);
            SetPos (X,Y);
        End.

SetRes procedure - Grafix
Function        Puts a value into the VGA SetRes register.
Declaration     SetRes (P : Byte);
Remarks         The byte P will be placed into the register.

SetTPointer procedure - Mouse
Function        Defines the shape and attributes of the mouse pointer
        in text modes.
Declaration     SetTPointer ( ANDM, XORM : Word; SH : Boolean );
Remarks         If SH is True then the hardware cursor is used.This
        cursor is defined by CursorOn or is the default cursor.
        If SH is False then ANDM is the AND mask value and XORM is
        the XOR mask value. The following table shows how to define
        these masks.
            Bits    Significance
            0-7     Character Code
            8-10    Foreground Colour
            11      Intensity (or upper block of colours)
            12-14   BackGround Colour
            15      Blink (or upper block of colours)

        The default values are ANDM = $77FF and XORM = $7700.
        All the mouse routines work with pixels even in text mode
        where we would use character spaces. Conversion is easy as
        in 80x25 text mode the screen is 640x200 pixels. This
        obviously means that each character is 8x8 pixels. So to get
        from characters to pixels multiply by 8 and to get from
        pixels to characters divide by 8. That's not quite right
        because of the posistion of the hotspots in text mode. The
        character posistions start at 1,1 whilst pixels start at 0,0.
        So you have to take one away from your character locations
        before you multiply. Likewise when converting from pixels to
        characters you have to add one to each of the locations after
        division. As a simple example say we wanted to restrict the
        mouse to a box on the screen where the top left coord is 5,10
        and the bottom right coord is 30,20. We simply take one from
        each of these and multiply by 8.

            4* 8 = 32
            9* 8 = 72
            29 * 8 = 232
            19 * 8 = 152

        So our call to SetLimits will look like this:

            SetLimit (32,72,232,152);

        In 43x80 or 50x80 mode each character is only 8x8 but the
        screen dimensions are 640x344 and 640x400 respectivley.
Example
        Uses Mouse;
        Begin
            if not MReset then Halt(0);
            Writeln ('New Style Pointer!');
            SetTPointer ($7777,$FFFF,False);
            repeat until GetButton>0;
        End.

Sinh function - Maths
Function        Returns the Hyp sine of the argument.
Declaration     Sinh (X : Real);
Result Type     Real
Remarks         X is a real type expression. The result is Hyp sine of X.
Example
        Uses Maths;
        Begin
            Writeln (Sinh(2));{ 3.6268 }
            Writeln (Sinh(-4)); { -27.29 }
        End.

StartAddr procedure - Grafix
Function        Puts a value into the VGA Start Address register.
Declaration     StartAddr (P : Byte);
Remarks         The byte P will be placed into the register.

Subtract_Matrix procedure - Matrices
Function        Subtracts two matrices.
Declaration     Subtract_Matrix ( M1,M2 : Matrix; var M : Matrix );
Remarks         Returns in matrix M the result of M1 - M2.

Tanh function - Maths
Function        Returns the Hyp Tangent of the argument.
Declaration     Tanh (X : Real);
Result Type     Real
Remarks         X is a real type expression. The result is Hyp tangent
        of X.
Example
        Uses Maths;
        Begin
            Writeln (Tanh(2));{ 0.964}
            Writeln (Tanh(-4)); { -0.999 }
        End.

UpString function - Screen
Function        Converts a string to uppercase.
Declaration     UpString ( S : String );
Result Type     String
Remarks         Returns S in uppercase. Non alphabetic characters are
        left alone.
Example
        Uses Screen;
        Begin
            Writeln (UpString ('rafe's tp collection'));
        End.

VLine procedure - VGA
Function        Draws a vertical line in mode 13h.
Declaration     VLine ( L,X,Y : Word; Col : Byte );
Remarks         Draws a vertical line of length L starting at X,Y and
        in colour  Col in mode 13h (320x200x256 VGA graphics mode).

VGAOff procedure - VGA
Function        Turns off the VGA screen.
Declaration     VGAOff;
Remarks         Turns off the VGA screen.

VGAOn procedure - VGA
Function        Turns on the VGA screen.
Declaration     VGAOn;
Remarks         Turns on a VGA screen having been switched off with VGAOff.

Wallpaper procedure - Screen
Function        Wallpapers the screen.
Declaration     Wallpaper (C : Char);
Remarks         Fills the screen with character C in the current screen
        colours.

Wrte procedure - Screen
Function        Faster version of WRITE.
Declaration     Wrte (X,Y:Byte; Var S:String; F,G:Byte);
Remarks         Writes a the string S directly into video RAM at the
        screen posistion denoted by X,Y. F is the foreground color
        whilst B is the background color. NOTE: this procedure causes
        snow on a CGA adaptor.